Developer CD Series 2000 August: Tool Chest/Dev.CD Aug 00 TC Disk 1.toast/pc/sample code/contributed/waste/waste pascal interfaces/wepascalcfmglue.p

Text File | 2000-06-23 | 13.4 KB | 355 lines

UNIT WEPascalCFMGlue;

{ WASTE Pascal CFM glue code }
{ version 1.3 (January 1998) }

{ RATIONALE: the NewWE≈Proc calls used to create routine descriptors   }
{  for several WASTE callbacks are defined as actual entry points in   }
{  WASTE.p (if generating CFM-based code), but in the C code they're   }
{  really only macros.  So when you link a CFM Pascal program to a     }
{  WASTE library built from C code, you'll want to include this glue   }
{  file to avoid link errors.                                          }

{ Copyright © 1993-1998 Marco Piovanelli }
{ All Rights Reserved }

INTERFACE
    USES
        WASTE;

IMPLEMENTATION

{$IFC GENERATINGCFM}
{$PUSH}
{$Z+}

    FUNCTION NewWEClickLoopProc (userRoutine: WEClickLoopProcPtr): WEClickLoopUPP;
    BEGIN
        NewWEClickLoopProc := NewRoutineDescriptor(userRoutine, uppWEClickLoopProcInfo, GetCurrentArchitecture);
    END;  { NewWEClickLoopProc }

    FUNCTION NewWEScrollProc (userRoutine: WEScrollProcPtr): WEScrollUPP;
    BEGIN
        NewWEScrollProc := NewRoutineDescriptor(userRoutine, uppWEScrollProcInfo, GetCurrentArchitecture);
    END;  { NewWEScrollProc }

    FUNCTION NewWETSMPreUpdateProc (userRoutine: WETSMPreUpdateProcPtr): WETSMPreUpdateUPP;
    BEGIN
        NewWETSMPreUpdateProc := NewRoutineDescriptor(userRoutine, uppWETSMPreUpdateProcInfo, GetCurrentArchitecture);
    END;  { NewWETSMPreUpdateProc }

    FUNCTION NewWETSMPostUpdateProc (userRoutine: WETSMPostUpdateProcPtr): WETSMPostUpdateUPP;
    BEGIN
        NewWETSMPostUpdateProc := NewRoutineDescriptor(userRoutine, uppWETSMPostUpdateProcInfo, GetCurrentArchitecture);
    END;  { NewWETSMPostUpdateProc }

    FUNCTION NewWEPreTrackDragProc (userRoutine: WEPreTrackDragProcPtr): WEPreTrackDragUPP;
    BEGIN
        NewWEPreTrackDragProc := NewRoutineDescriptor(userRoutine, uppWEPreTrackDragProcInfo, GetCurrentArchitecture);
    END;  { NewWEPreTrackDragProc }

    FUNCTION NewWETranslateDragProc (userRoutine: WETranslateDragProcPtr): WETranslateDragUPP;
    BEGIN
        NewWETranslateDragProc := NewRoutineDescriptor(userRoutine, uppWETranslateDragProcInfo, GetCurrentArchitecture);
    END;  { NewWETranslateDragProc }

    FUNCTION NewWEHiliteDropAreaProc (userRoutine: WEHiliteDropAreaProcPtr): WEHiliteDropAreaUPP;
    BEGIN
        NewWEHiliteDropAreaProc := NewRoutineDescriptor(userRoutine, uppWEHiliteDropAreaProcInfo, GetCurrentArchitecture);
    END;  { NewWEHiliteDropAreaProc }

    FUNCTION NewWEFontIDToNameProc (userRoutine: WEFontIDToNameProcPtr): WEFontIDToNameUPP;
    BEGIN
        NewWEFontIDToNameProc := NewRoutineDescriptor(userRoutine, uppWEFontIDToNameProcInfo, GetCurrentArchitecture);
    END;  { NewWEFontIDToNameProc }

    FUNCTION NewWEFontNameToIDProc (userRoutine: WEFontNameToIDProcPtr): WEFontNameToIDUPP;
    BEGIN
        NewWEFontNameToIDProc := NewRoutineDescriptor(userRoutine, uppWEFontNameToIDProcInfo, GetCurrentArchitecture);
    END;  { NewWEFontNameToIDProc }

    FUNCTION NewWEDrawTextProc (userRoutine: WEDrawTextProcPtr): WEDrawTextUPP;
    BEGIN
        NewWEDrawTextProc := NewRoutineDescriptor(userRoutine, uppWEDrawTextProcInfo, GetCurrentArchitecture);
    END;  { NewWEDrawTextProc }

    FUNCTION NewWEPixelToCharProc (userRoutine: WEPixelToCharProcPtr): WEPixelToCharUPP;
    BEGIN
        NewWEPixelToCharProc := NewRoutineDescriptor(userRoutine, uppWEPixelToCharProcInfo, GetCurrentArchitecture);
    END;  { NewWEPixelToCharProc }

    FUNCTION NewWECharToPixelProc (userRoutine: WECharToPixelProcPtr): WECharToPixelUPP;
    BEGIN
        NewWECharToPixelProc := NewRoutineDescriptor(userRoutine, uppWECharToPixelProcInfo, GetCurrentArchitecture);
    END;  { NewWECharToPixelProc }

    FUNCTION NewWELineBreakProc (userRoutine: WELineBreakProcPtr): WELineBreakUPP;
    BEGIN
        NewWELineBreakProc := NewRoutineDescriptor(userRoutine, uppWELineBreakProcInfo, GetCurrentArchitecture);
    END;  { NewWELineBreakProc }

    FUNCTION NewWEWordBreakProc (userRoutine: WEWordBreakProcPtr): WEWordBreakUPP;
    BEGIN
        NewWEWordBreakProc := NewRoutineDescriptor(userRoutine, uppWEWordBreakProcInfo, GetCurrentArchitecture);
    END;  { NewWEWordBreakProc }

    FUNCTION NewWECharByteProc (userRoutine: WECharByteProcPtr): WECharByteUPP;
    BEGIN
        NewWECharByteProc := NewRoutineDescriptor(userRoutine, uppWECharByteProcInfo, GetCurrentArchitecture);
    END;  { NewWECharByteProc }

    FUNCTION NewWECharTypeProc (userRoutine: WECharTypeProcPtr): WECharTypeUPP;
    BEGIN
        NewWECharTypeProc := NewRoutineDescriptor(userRoutine, uppWECharTypeProcInfo, GetCurrentArchitecture);
    END;  { NewWECharTypeProc }

    FUNCTION NewWEEraseProc (userRoutine: WEEraseProcPtr): WEEraseUPP;
    BEGIN
        NewWEEraseProc := NewRoutineDescriptor(userRoutine, uppWEEraseProcInfo, GetCurrentArchitecture);
    END;  { NewWEEraseProc }

    FUNCTION NewWEFluxProc (userRoutine: WEFluxProcPtr): WEFluxUPP;
    BEGIN
        NewWEFluxProc := NewRoutineDescriptor(userRoutine, uppWEFluxProcInfo, GetCurrentArchitecture);
    END;  { NewWEFluxProc }

    FUNCTION NewWENewObjectProc (userRoutine: WENewObjectProcPtr): WENewObjectUPP;
    BEGIN
        NewWENewObjectProc := NewRoutineDescriptor(userRoutine, uppWENewObjectProcInfo, GetCurrentArchitecture);
    END;  { NewWENewObjectProc }

    FUNCTION NewWEDisposeObjectProc (userRoutine: WEDisposeObjectProcPtr): WEDisposeObjectUPP;
    BEGIN
        NewWEDisposeObjectProc := NewRoutineDescriptor(userRoutine, uppWEDisposeObjectProcInfo, GetCurrentArchitecture);
    END;  { NewWEDisposeObjectProc }

    FUNCTION NewWEDrawObjectProc (userRoutine: WEDrawObjectProcPtr): WEDrawObjectUPP;
    BEGIN
        NewWEDrawObjectProc := NewRoutineDescriptor(userRoutine, uppWEDrawObjectProcInfo, GetCurrentArchitecture);
    END;  { NewWEDrawObjectProc }

    FUNCTION NewWEClickObjectProc (userRoutine: WEClickObjectProcPtr): WEClickObjectUPP;
    BEGIN
        NewWEClickObjectProc := NewRoutineDescriptor(userRoutine, uppWEClickObjectProcInfo, GetCurrentArchitecture);
    END;  { NewWEClickObjectProc }

    FUNCTION NewWEStreamObjectProc (userRoutine: WEStreamObjectProcPtr): WEStreamObjectUPP;
    BEGIN
        NewWEStreamObjectProc := NewRoutineDescriptor(userRoutine, uppWEStreamObjectProcInfo, GetCurrentArchitecture);
    END;  { NewWEStreamObjectProc }

    FUNCTION CallWEClickLoopProc (we: WEReference;
                                    userRoutine: WEClickLoopUPP): BOOLEAN;
    BEGIN
        CallWEClickLoopProc := BOOLEAN(CallUniversalProc(userRoutine, uppWEClickLoopProcInfo, we));
    END;  { CallWEClickLoopProc }

    PROCEDURE CallWEScrollProc (we: WEReference;
                                    userRoutine: WEScrollUPP);
        VAR
            retval: LONGINT;
    BEGIN
        retval := CallUniversalProc(userRoutine, uppWEScrollProcInfo, we);
    END;  { CallWEScrollProc }

    PROCEDURE CallWETSMPreUpdateProc (we: WEReference;
                                    userRoutine: WETSMPreUpdateUPP);
        VAR
            retval: LONGINT;
    BEGIN
        retval := CallUniversalProc(userRoutine, uppWETSMPreUpdateProcInfo, we);
    END;  { CallWETSMPreUpdateProc }

    PROCEDURE CallWETSMPostUpdateProc (we: WEReference;
                                    fixLength: LONGINT;
                                    inputAreaStart, inputAreaEnd: LONGINT;
                                    pinRangeStart, pinRangeEnd: LONGINT;
                                    userRoutine: WETSMPostUpdateUPP);
        VAR
            retval: LONGINT;
    BEGIN
        retval := CallUniversalProc(userRoutine, uppWETSMPostUpdateProcInfo, we, fixLength, inputAreaStart, inputAreaEnd, pinRangeStart, pinRangeEnd);
    END;  { CallWETSMPostUpdateProc }

    FUNCTION CallWEPreTrackDragProc (drag: DragReference;
                                    we: WEReference;
                                    userRoutine: WEPreTrackDragUPP): OSErr;
    BEGIN
        CallWEPreTrackDragProc := CallUniversalProc(userRoutine, uppWEPreTrackDragProcInfo, drag, we);
    END;  { CallWEPreTrackDragProc }

    FUNCTION CallWETranslateDragProc (drag: DragReference;
                                    item: ItemReference;
                                    requestedType: FlavorType;
                                    putDataHere: Handle;
                                    dropOffset: LONGINT;
                                    we: WEReference;
                                    userRoutine: WETranslateDragUPP): OSErr;
    BEGIN
        CallWETranslateDragProc := CallUniversalProc(userRoutine, uppWETranslateDragProcInfo, drag, item, requestedType, putDataHere);
    END;  { CallWETranslateDragProc }

    FUNCTION CallWEHiliteDropAreaProc (drag: DragReference;
                                    hiliteFlag: BOOLEAN;
                                    we: WEReference;
                                    userRoutine: WEHiliteDropAreaUPP): OSErr;
    BEGIN
        CallWEHiliteDropAreaProc := CallUniversalProc(userRoutine, uppWEHiliteDropAreaProcInfo, drag, hiliteFlag, we);
    END;  { CallWEHiliteDropAreaProc }

    FUNCTION CallWEFontIDToNameProc (fontID: INTEGER;
                                    VAR fontName: Str255;
                                    userRoutine: WEFontIDToNameUPP): OSErr;
    BEGIN
        CallWEFontIDToNameProc := CallUniversalProc(userRoutine, uppWEFontIDToNameProcInfo, fontID, fontName);
    END;  { CallWEFontIDToNameProc }

    FUNCTION CallWEFontNameToIDProc ({CONST} VAR fontName: Str255;
                                    oldFontID: INTEGER;
                                    VAR newFontID: INTEGER;
                                    userRoutine: WEFontNameToIDUPP): OSErr;
    BEGIN
        CallWEFontNameToIDProc := CallUniversalProc(userRoutine, uppWEFontNameToIDProcInfo, fontName, oldFontID, newFontID);
    END;  { CallWEFontNameToIDProc }

    PROCEDURE CallWEDrawTextProc (pText: Ptr;
                                    textLength: LONGINT;
                                    slop: Fixed;
                                    styleRunPosition: JustStyleCode;
                                    we: WEReference;
                                    userRoutine: WEDrawTextUPP);
        VAR
            retval: LONGINT;
    BEGIN
        retval := CallUniversalProc(userRoutine, uppWEDrawTextProcInfo, pText, textLength, slop, styleRunPosition, we);
    END;  { CallWEDrawTextProc }

    FUNCTION CallWEPixelToCharProc (pText: Ptr;
                                    textLength: LONGINT;
                                    slop: Fixed;
                                    VAR width: Fixed;
                                    VAR edge: SignedByte;
                                    styleRunPosition: JustStyleCode;
                                    hPos: Fixed;
                                    we: WEReference;
                                    userRoutine: WEPixelToCharUPP): LONGINT;
    BEGIN
        CallWEPixelToCharProc := CallUniversalProc(userRoutine, uppWEPixelToCharProcInfo, pText, textLength, slop, width, edge, styleRunPosition, hPos, we);
    END;  { CallWEPixelToCharProc }

    FUNCTION CallWECharToPixelProc (pText: Ptr;
                                    textLength: LONGINT;
                                    slop: Fixed;
                                    offset: LONGINT;
                                    direction: INTEGER;
                                    styleRunPosition: JustStyleCode;
                                    hPos: INTEGER;
                                    we: WEReference;
                                    userRoutine: WECharToPixelUPP): INTEGER;
    BEGIN
        CallWECharToPixelProc := CallUniversalProc(userRoutine, uppWECharToPixelProcInfo, pText, textLength, slop, offset, direction, styleRunPosition, hPos, we);
    END;  { CallWECharToPixelProc }

    FUNCTION CallWELineBreakProc (pText: Ptr;
                                    textLength: LONGINT;
                                    textStart, textEnd: LONGINT;
                                    VAR textWidth: Fixed;
                                    VAR textOffset: LONGINT;
                                    we: WEReference;
                                    userRoutine: WELineBreakUPP): StyledLineBreakCode;
    BEGIN
        CallWELineBreakProc := CallUniversalProc(userRoutine, uppWELineBreakProcInfo, pText, textLength, textStart, textEnd, textWidth, textOffset, we);
    END;  { CallWELineBreakProc }

    PROCEDURE CallWEWordBreakProc (pText: Ptr;
                                    textLength, offset: INTEGER;
                                    edge: SignedByte;
                                    VAR breakOffsets: OffsetTable;
                                    script: ScriptCode;
                                    we: WEReference;
                                    userRoutine: WEWordBreakUPP);
        VAR
            retval: LONGINT;
    BEGIN
        retval := CallUniversalProc(userRoutine, uppWEWordBreakProcInfo, pText, textLength, offset, edge, breakOffsets, script, we);
    END;  { CallWEWordBreakProc }

    FUNCTION CallWECharByteProc (pText: Ptr;
                                    textOffset: INTEGER;
                                    script: ScriptCode;
                                    we: WEReference;
                                    userRoutine: WECharByteUPP): INTEGER;
    BEGIN
        CallWECharByteProc := CallUniversalProc(userRoutine, uppWECharByteProcInfo, pText, textOffset, script, we);
    END;  { CallWECharByteProc }

    FUNCTION CallWECharTypeProc (pText: Ptr;
                                    textOffset: INTEGER;
                                    script: ScriptCode;
                                    we: WEReference;
                                    userRoutine: WECharTypeUPP): INTEGER;
    BEGIN
        CallWECharTypeProc := CallUniversalProc(userRoutine, uppWECharTypeProcInfo, pText, textOffset, script, we);
    END;  { CallWECharTypeProc }

    PROCEDURE CallWEEraseProc ({CONST} VAR area: Rect;
                                    we: WEReference;
                                    userRoutine: WEEraseUPP);
        VAR
            retval: LONGINT;
    BEGIN
        retval := CallUniversalProc(userRoutine, uppWEEraseProcInfo, area, we);
    END;  { CallWEEraseProc }

    PROCEDURE CallWEFluxProc (offset: LONGINT;
                                    delta: LONGINT;
                                    we: WEReference;
                                    userRoutine: WEFluxUPP);
        VAR
            retval: LONGINT;
    BEGIN
        retval := CallUniversalProc(userRoutine, uppWEFluxProcInfo, offset, delta, we);
    END;  { CallWEFluxProc }

    FUNCTION CallWENewObjectProc (VAR defaultObjectSize: Point;
                                    objectRef: WEObjectReference;
                                    userRoutine: WENewObjectUPP): OSErr;
    BEGIN
        CallWENewObjectProc := CallUniversalProc(userRoutine, uppWENewObjectProcInfo, defaultObjectSize, objectRef);
    END;  { CallWENewObjectProc }

    FUNCTION CallWEDisposeObjectProc (objectRef: WEObjectReference;
                                    userRoutine: WEDisposeObjectUPP): OSErr;
    BEGIN
        CallWEDisposeObjectProc := CallUniversalProc(userRoutine, uppWEDisposeObjectProcInfo, objectRef);
    END;  { CallWEDisposeObjectProc }

    FUNCTION CallWEDrawObjectProc ({const} VAR destRect: Rect;
                                    objectRef: WEObjectReference;
                                    userRoutine: WEDrawObjectUPP): OSErr;
    BEGIN
        CallWEDrawObjectProc := CallUniversalProc(userRoutine, uppWEDrawObjectProcInfo, destRect, objectRef);
    END;  { CallWEDrawObjectProc }

    FUNCTION CallWEClickObjectProc (hitPoint: Point;
                                    modifiers: EventModifiers;
                                    clickTime: LONGINT;
                                    objectRef: WEObjectReference;
                                    userRoutine: WEClickObjectUPP): BOOLEAN;
    BEGIN
        CallWEClickObjectProc := BOOLEAN(CallUniversalProc(userRoutine, uppWEClickObjectProcInfo, hitPoint, modifiers, clickTime, objectRef));
    END;  { CallWEClickObjectProc }

    FUNCTION CallWEStreamObjectProc (destKind: INTEGER;
                                    VAR theType: FlavorType;
                                    putDataHere: Handle;
                                    objectRef: WEObjectReference;
                                    userRoutine: WEStreamObjectUPP): OSErr;
    BEGIN
        CallWEStreamObjectProc := CallUniversalProc(userRoutine, uppWEStreamObjectProcInfo, destKind, theType, putDataHere, objectRef);
    END;  { CallWEStreamObjectProc }

{$POP}
{$ENDC}

END.